Reviewing files that changed from the base of the PR and between 3d39e48 and 8254eba.

• vendor-bin/tools/composer.lock is excluded by !**/*.lock

• .github/workflows/continuous-integration.yml (1 hunks)
• .github/workflows/static-analysis.yml (2 hunks)
• .gitignore (1 hunks)
• LICENSE (1 hunks)
• README.md (3 hunks)
• UPGRADE.md (1 hunks)
• composer.json (1 hunks)
• phpunit.xml.dist (1 hunks)
• rector.php (1 hunks)
• src/AuraSqlBaseModule.php (2 hunks)
• src/AuraSqlConnectionInterceptor.php (1 hunks)
• src/AuraSqlEnvModule.php (2 hunks)
• src/AuraSqlLocatorModule.php (3 hunks)
• src/AuraSqlMasterDbInterceptor.php (1 hunks)
• src/AuraSqlMasterModule.php (3 hunks)
• src/AuraSqlModule.php (3 hunks)
• src/AuraSqlProfileModule.php (1 hunks)
• src/AuraSqlQueryDeleteProvider.php (1 hunks)
• src/AuraSqlQueryInsertProvider.php (1 hunks)
• src/AuraSqlQueryModule.php (2 hunks)
• src/AuraSqlQuerySelectProvider.php (1 hunks)
• src/AuraSqlQueryUpdateProvider.php (1 hunks)
• src/AuraSqlReplicationDbProvider.php (3 hunks)
• src/AuraSqlReplicationModule.php (2 hunks)
• src/AuraSqlSlaveDbInterceptor.php (1 hunks)
• src/Connection.php (2 hunks)
• src/EnvConnection.php (2 hunks)
• src/Exception/InvalidTransactionalPropertyException.php (1 hunks)
• src/Exception/NotInitialized.php (1 hunks)
• src/Exception/RollbackException.php (1 hunks)
• src/IsInMethodMatcher.php (3 hunks)
• src/NamedExtendedPdoProvider.php (2 hunks)
• src/NamedPdoEnvModule.php (2 hunks)
• src/NamedPdoModule.php (3 hunks)
• src/Pagerfanta/AuraSqlPager.php (7 hunks)
• src/Pagerfanta/AuraSqlPagerFactory.php (1 hunks)
• src/Pagerfanta/AuraSqlPagerModule.php (1 hunks)
• src/Pagerfanta/AuraSqlQueryAdapter.php (4 hunks)
• src/Pagerfanta/AuraSqlQueryPager.php (7 hunks)
• src/Pagerfanta/AuraSqlQueryPagerFactory.php (1 hunks)
• src/Pagerfanta/DefaultRouteGenerator.php (1 hunks)
• src/Pagerfanta/ExtendedPdoAdapter.php (4 hunks)
• src/Pagerfanta/FetchAssoc.php (2 hunks)
• src/Pagerfanta/FetchEntity.php (2 hunks)
• src/Pagerfanta/Page.php (3 hunks)
• src/ProfilerProvider.php (1 hunks)
• src/TransactionalInterceptor.php (2 hunks)
• src/TransactionalModule.php (1 hunks)
• tests/AuraSqlLocatorModuleTest.php (1 hunks)
• tests/AuraSqlModuleTest.php (2 hunks)
• tests/AuraSqlProfileModuleTest.php (2 hunks)
• tests/AuraSqlQueryModuleTest.php (1 hunks)
• tests/AuraSqlReplicationModuleTest.php (3 hunks)
• tests/NamedPdoEnvModuleTest.php (1 hunks)
• tests/NamedPdoModuleTest.php (3 hunks)
• tests/Pagerfanta/AuraSqlPagerModuleTest.php (7 hunks)
• tests/Pagerfanta/AuraSqlQueryPagerModuleTest.php (6 hunks)
• tests/Pagerfanta/ExtendedPdoAdapterTest.php (2 hunks)
• tests/TransactionalTest.php (3 hunks)
• vendor-bin/tools/composer.json (1 hunks)

src/EnvConnection.php (2)

8-8: LGTM: Appropriate import for security enhancement.

The SensitiveParameter import is correctly added to support the new attribute usage below.

---

29-30: Excellent security enhancement with #[SensitiveParameter].

The #[SensitiveParameter] attribute is correctly applied to the password parameter. This PHP 8.2+ feature ensures that sensitive data like passwords are redacted from stack traces and error reports, preventing accidental exposure of credentials in logs or debugging output.

This change aligns perfectly with the PR's security improvements and PHP 8.4 modernization goals.

src/Connection.php (3)

8-8: LGTM! Necessary import for security enhancement.

The addition of the SensitiveParameter import is required to support the #[SensitiveParameter] attribute usage on the password parameter, which is an excellent security improvement.

---

10-10: Approve the final class declaration for improved security.

Making the Connection class final is a good design decision that:

• Prevents unintended inheritance and potential security vulnerabilities
• Provides clearer API boundaries
• Allows for better PHP engine optimizations

This is an appropriate breaking change for a major version upgrade (2.x).

---

21-22: Excellent security enhancement with SensitiveParameter attribute.

The addition of #[SensitiveParameter] to the password parameter is a significant security improvement that:

• Prevents password values from appearing in stack traces
• Redacts sensitive data in debugging output and var_dump()
• Enhances overall security posture of the application

This follows PHP 8.2+ best practices for handling sensitive data and aligns perfectly with the modernization goals of this PR.

src/NamedExtendedPdoProvider.php (2)

15-15: Final class declaration aligns with project conventions
Marking provider classes as final enforces immutability and prevents unintended extension, matching the updates in other modules.

---

35-41: Override annotation on get method is correct
The get(): ExtendedPdo signature adheres to the generic ProviderInterface<ExtendedPdo> contract, and marking it with #[Override] enhances clarity and Psalm verification.

src/IsInMethodMatcher.php (4)

14-14: Consistent immutability: mark class as final
Marking IsInMethodMatcher as final enforces immutability and signals the class isn’t intended for extension, aligning with the PHP 8.4 modernization strategy.

---

24-24: Annotate matchesClass with #[Override]
Adding the Override attribute makes it explicit that this method overrides the parent declaration and works in concert with the updated Psalm configuration for attribute checks.

---

37-37: Annotate matchesMethod with #[Override]
Similarly, this attribute clarifies that matchesMethod is an override, improving readability and static-analysis accuracy.

---

7-7:

❓ Verification inconclusive

Ensure correct import for Override attribute
The use Override; statement assumes there’s an attribute class named Override in the root namespace. Please confirm that the Override attribute is defined and autoloadable from this namespace, or adjust the import to its fully-qualified path.

---

🏁 Script executed:

#!/bin/bash
# Verify the existence of the Override attribute
rg --files-with-matches "class Override" -n .
rg --files-with-matches "interface Override" -n .

Length of output: 99

---

Ensure correct import for Override attribute
I couldn’t locate any class Override or interface Override definitions in the repository. Please verify that an Override attribute exists and is autoloadable (for example via Composer), or update the import to its full namespace.

• src/IsInMethodMatcher.php: line 7 (use Override;)

src/Exception/RollbackException.php (1)

9-9:

✅ Verification successful

Approve final class enforcement Marking RollbackException as final aligns with the PR’s modernization goals to prevent subclassing and improve immutability.

Run this script to verify no unintended subclasses exist in the codebase:

---

🏁 Script executed:

#!/bin/bash
# Verify no classes extend RollbackException
rg -n "extends\s\+RollbackException"

Length of output: 38

---

🏁 Script executed:

#!/bin/bash
# Robust search for any subclasses of RollbackException
rg -n "class\s\+\w\+\s\+extends\s\+.*RollbackException"
rg -n "extends\s\+.*RollbackException"

Length of output: 98

---

Approve final class enforcement
Marking RollbackException as final aligns with the PR’s modernization goals to prevent subclassing and improve immutability.

• Verified no subclasses exist by running:

• rg -n "class\s\+\w\+\s\+extends\s\+.*RollbackException"
• rg -n "extends\s\+.*RollbackException"
  No matches found, confirming it’s safe to seal this class.

src/Exception/InvalidTransactionalPropertyException.php (1)

9-9:

✅ Verification successful

Approve final class enforcement Declaring InvalidTransactionalPropertyException as final is consistent with the shift towards immutability and preventing unintended inheritance.

Use this script to confirm there are no subclasses extending it:

---

🏁 Script executed:

#!/bin/bash
# Verify no classes extend InvalidTransactionalPropertyException
rg -n "extends\s\+InvalidTransactionalPropertyException"

Length of output: 58

---

🏁 Script executed:

#!/bin/bash
# Verify no classes extend InvalidTransactionalPropertyException (direct or namespaced)
rg -n 'extends\s+InvalidTransactionalPropertyException'
rg -n 'extends\s+\\?[\w\\]*InvalidTransactionalPropertyException'

Length of output: 125

---

Approve final class enforcement
Ran rg -n 'extends\s+InvalidTransactionalPropertyException' (including namespaced variants); no subclasses found. Declaring InvalidTransactionalPropertyException as final is safe and requires no further changes.

src/Exception/NotInitialized.php (1)

9-9:

✅ Verification successful

Approve final class enforcement Making NotInitialized a final class fits the pattern of locking down exception hierarchies for clarity and immutability.

Validate absence of subclasses with:

---

🏁 Script executed:

#!/bin/bash
# Verify no classes extend NotInitialized
rg -n "extends\s\+NotInitialized"

Length of output: 35

---

To ensure we catch any subclass definitions—regardless of namespace or alias—let’s run a broader search:

---

🏁 Script executed:

#!/bin/bash
# 1. Case-insensitive grep for any “extends …NotInitialized”
rg -in "extends\s+.*NotInitialized"

# 2. AST-based check for direct subclassing of NotInitialized
ast-grep --pattern $'class $_ extends NotInitialized { $$$ }'

Length of output: 100

---

Approve final class enforcement
Making NotInitialized a final class fits our pattern of locking down exception hierarchies for clarity and immutability. Verified via Ripgrep and AST-grep searches that no classes extend NotInitialized.

LICENSE (1)

3-3: LGTM! Standard copyright year update.

The copyright year has been appropriately updated to include 2025, which is a routine maintenance practice.

composer.json (1)

16-16: LGTM! Good backward compatibility for pagerfanta.

The expanded version constraint allows compatibility with both pagerfanta v3.5+ and v4.0+, providing good flexibility for downstream users.

src/AuraSqlQueryModule.php (3)

11-11: LGTM! Proper import for Override attribute.

The Override import is correctly added to support the #[Override] attribute usage.

---

15-15: LGTM! Making the class final improves encapsulation.

Declaring the module class as final prevents unintended inheritance and is a good practice for concrete module implementations.

---

25-25: LGTM! Correct usage of Override attribute.

The #[Override] attribute is properly applied to the configure() method which overrides AbstractModule::configure(). This provides compile-time verification and improves code clarity.

vendor-bin/tools/composer.json (2)

10-10: LGTM! Rector version is stable and appropriate.

The rector version ^2.0.16 is a stable release and aligns well with the PR's goal of using Rector for PHP 8.4 modernization.

---

4-6:

❓ Verification inconclusive

Consider using stable versions instead of dev/RC releases.

Using development and release candidate versions introduces potential instability:

• phpmd/phpmd: "3.x-dev" - dev versions can change without notice
• pdepend/pdepend: "3.x-dev" - same stability concern
• phpmetrics/phpmetrics: "3.0.0-rc.8@RC" - release candidates may have bugs

Please verify if stable versions are available for PHP 8.4 compatibility:

---

🌐 Web query:

Are stable versions of phpmd/phpmd 3.x, pdepend/pdepend 3.x, and phpmetrics/phpmetrics 3.x available that support PHP 8.4?

💡 Result:

Based on the search results, I'll analyze the current status of these PHP static analysis tools and their compatibility with PHP 8.4.

PHPMD (PHP Mess Detector)

Currently, there is no stable version of PHPMD 3.x available. The latest stable release is PHPMD 2.15.0, which was released on December 11, 2023[3]. This version requires pdepend/pdepend 2.16.1, which includes support for PHP 8.3 syntax[3][8].

However, PHPMD is facing compatibility issues with PHP 8.4. There's an open issue (#1219) specifically about PHP 8.4 support, where users are encountering errors like "Unexpected token: ->" when using PHPMD with PHP 8.4[1]. A user in this issue mentioned that using the development version 3.x-dev appears to work with PHP 8.4, but there's no stable 3.x release yet[1].

PDepend

For PDepend, the latest stable release is version 2.16.2[10]. There's no indication in the search results of a stable 3.x version being available. PDepend 2.16.1 added support for PHP 8.3 syntax[3][8], but there's no explicit mention of PHP 8.4 support in the most recent stable release (2.16.2).

PhpMetrics

PhpMetrics has a version 3.0 in development, but it's currently in release candidate status (up to rc8 as of the search results). The most recent release candidate mentioned is v3.0.0-rc7, released on February 4, 2025[7]. This version requires PHP 8.1 minimum[7], but there's no specific mention of PHP 8.4 compatibility in the search results.

Summary

None of these tools currently have stable 3.x versions that explicitly support PHP 8.4:

1. PHPMD: No stable 3.x version, though 3.x-dev might work with PHP 8.4 based on user comments
2. PDepend: No stable 3.x version, latest is 2.16.2 with PHP 8.3 support
3. PhpMetrics: Version 3.0 is in release candidate status (not stable), requires PHP 8.1+ but no explicit mention of PHP 8.4 compatibility

If you need to use these tools with PHP 8.4, you might need to wait for stable releases or use development versions with caution.

Citations:

• 1: PHP 8.4 support phpmd/phpmd#1219
• 2: https://phpmd.org
• 3: https://github.com/phpmd/phpmd/releases
• 4: https://www.codetriage.com/phpmd/phpmd?issues_before=537085328
• 5: https://scrutinizer-ci.com/g/phpmd/phpmd/inspections?type=github_pr&branchReference=master&page=7
• 6: https://pdepend.org/documentation/handbook/installation/index.html
• 7: https://github.com/phpmetrics/PhpMetrics/releases
• 8: https://phpmd.org/download/releases/index.html
• 9: https://phpmd.org/support/index.html
• 10: https://pdepend.org

---

Review stability of static analysis dependencies

The requested 3.x/RC releases are not yet stable or officially supporting PHP 8.4:

• phpmd/phpmd: currently no stable 3.x release (latest stable 2.15.0 supports PHP 8.3; see issue #1219 for PHP 8.4 errors)
• pdepend/pdepend: no stable 3.x release (latest stable 2.16.2 supports PHP 8.3)
• phpmetrics/phpmetrics: only RC available (3.0.0-rc.8; requires PHP 8.1+, no explicit PHP 8.4 support)

Recommendations:

• If you need maximum stability, pin to the latest stable releases:

  - "phpmd/phpmd": "3.x-dev"
  + "phpmd/phpmd": "^2.15"
  
  - "pdepend/pdepend": "3.x-dev"
  + "pdepend/pdepend": "^2.16"

• If PHP 8.4 compatibility is critical today, you may proceed with the dev/RC versions but ensure CI/tests cover these tools and plan to upgrade once stable 3.x releases are published.

.gitignore (1)

8-10: LGTM! Clean reorganization of ignore patterns.

The reorganization groups PHPUnit cache files together and properly positions the vendor directory entry. This aligns well with the tooling updates mentioned in the PR.

src/AuraSqlProfileModule.php (3)

8-8: Good addition of Override import.

Properly imported the Override attribute for the method annotation below.

---

11-11: Excellent use of final keyword.

Making the class final prevents unintended inheritance and clearly communicates the design intent. This is a good modernization practice.

---

16-16: Great use of #[Override] attribute.

The #[Override] attribute provides compile-time safety by ensuring this method actually overrides a parent method, and serves as clear documentation of the intent.

src/AuraSqlModule.php (5)

9-12: Good addition of necessary imports.

Properly imported the Override and SensitiveParameter attributes for use in the class.

---

14-14: Excellent use of final keyword.

Making the main module class final prevents unintended inheritance and clearly communicates the design intent.

---

16-16: Good modernization with typed constant.

The explicitly typed constant improves type safety. Note that this feature requires PHP 8.3+, which aligns with your PHP 8.4 target.

🧰 Tools

🪛 PHPStan (2.1.15)

16-16: Class constants with native types are supported only on PHP 8.3 and later.

(classConstant.nativeTypeNotSupported)

---

29-30: Excellent security enhancement with #[SensitiveParameter].

Adding the #[SensitiveParameter] attribute to the password parameter is a great security practice. This prevents the password from appearing in stack traces and debug output, reducing the risk of accidental exposure of sensitive data.

---

41-41: Great use of #[Override] attribute.

The #[Override] attribute provides compile-time safety and clear documentation that this method overrides a parent method.

src/Pagerfanta/FetchAssoc.php (2)

8-8: Good addition of Override import.

Properly imported the Override attribute for the method annotation.

---

20-20: Excellent use of #[Override] attribute.

Adding the #[Override] attribute to the __invoke method provides compile-time safety by ensuring it properly implements the interface method, and serves as clear documentation.

tests/NamedPdoModuleTest.php (4)

20-20: LGTM: Syntactic improvement removing unnecessary parentheses.

The removal of parentheses around the Injector instantiation improves code readability while maintaining the same functionality.

---

37-37: LGTM: Consistent syntactic improvement.

The change aligns with the modernization effort and removes unnecessary parentheses without affecting behavior.

---

47-47: LGTM: Code readability improvement.

The simplified syntax is more readable and consistent with modern PHP conventions.

---

55-55: LGTM: Consistent refactoring pattern.

This change maintains consistency with the other similar refactoring changes in the file.

tests/NamedPdoEnvModuleTest.php (3)

24-24: LGTM: Syntactic simplification in test method.

The removal of unnecessary parentheses around Injector instantiation improves code readability while maintaining functionality.

---

31-31: LGTM: Consistent refactoring pattern.

This change aligns with the project-wide effort to modernize syntax and improve readability.

---

38-38: LGTM: Code modernization improvement.

The simplified syntax is cleaner and follows modern PHP conventions.

tests/AuraSqlQueryModuleTest.php (1)

57-57: LGTM: Syntactic improvement removing unnecessary parentheses.

The change simplifies the Injector instantiation syntax while maintaining the same functionality, improving code readability.

tests/AuraSqlLocatorModuleTest.php (1)

34-34: LGTM: Consistent syntactic modernization.

The removal of unnecessary parentheses around Injector instantiation in the setUp method improves readability and aligns with the project-wide refactoring effort.

tests/Pagerfanta/AuraSqlQueryPagerModuleTest.php (3)

8-8: LGTM: Proper PHPUnit 11 modernization

The import of PHPUnit\Framework\Attributes\Depends is correctly added to support the new attribute syntax for test dependencies.

---

17-17: LGTM: Code cleanup improves readability

Removing unnecessary parentheses around the new Injector(...) expressions improves code readability while maintaining the same functionality.

Also applies to: 29-29

---

38-38: LGTM: Proper migration to PHP 8 attributes

The replacement of PHPUnit @depends docblock annotations with #[Depends()] attributes is correct and aligns with PHPUnit 11 modernization. This syntax is more explicit and provides better IDE support and static analysis.

Also applies to: 58-58, 78-78, 86-86

src/AuraSqlLocatorModule.php (3)

8-8: LGTM: Required import for #[Override] attribute

The Override import is correctly added to support the PHP 8 #[Override] attribute syntax.

---

18-18: LGTM: Appropriate final class declaration

Marking the AuraSqlLocatorModule class as final is appropriate as it appears to be a concrete module implementation that should not be further extended. This aligns with the modernization goals and improves code safety.

---

38-38: LGTM: Proper use of #[Override] attribute

The #[Override] attribute is correctly applied to the configure() method, which overrides the abstract method from AbstractModule. This provides explicit documentation of the override relationship and enables static analysis tools like Psalm to verify the override is valid.

src/Pagerfanta/Page.php (3)

9-9: LGTM: Required import for #[Override] attribute

The Override import is correctly added to support the PHP 8 #[Override] attribute syntax.

---

53-53: LGTM: Proper #[Override] for interface implementation

The #[Override] attribute is correctly applied to the __toString() method, which implements the Stringable::__toString() interface method. This provides explicit documentation and static analysis verification.

---

68-68: LGTM: Proper #[Override] for interface implementation

The #[Override] attribute is correctly applied to the getIterator() method, which implements the IteratorAggregate::getIterator() interface method. This enhances code clarity and enables static analysis tools to verify the implementation.

src/AuraSqlEnvModule.php (3)

7-7: LGTM: Required import for #[Override] attribute

The Override import is correctly added to support the PHP 8 #[Override] attribute syntax.

---

10-10: LGTM: Appropriate final class declaration

Marking the AuraSqlEnvModule class as final is appropriate as it's a concrete module implementation that should not be further extended. This aligns with the modernization pattern seen across other modules in the codebase.

---

34-34: LGTM: Proper use of #[Override] attribute

The #[Override] attribute is correctly applied to the configure() method, which overrides the abstract method from AbstractModule. This is consistent with the pattern shown in the relevant code snippets from other modules like AuraSqlModule, NamedPdoModule, and NamedPdoEnvModule.

tests/TransactionalTest.php (1)

16-16: LGTM! Style improvement for object instantiation.

The removal of unnecessary parentheses around new Injector(...) instantiations improves code readability while maintaining identical functionality. This follows modern PHP style conventions.

Also applies to: 52-52, 87-87

src/AuraSqlReplicationModule.php (3)

9-9: LGTM! Proper import for Override attribute.

Adding the use Override; statement is correctly placed and necessary for the #[Override] attribute usage below.

---

15-15: LGTM! Making class final improves design clarity.

Marking the class as final prevents subclassing, which enhances performance and clearly communicates the design intent that this module shouldn't be extended.

---

28-28: LGTM! Override attribute improves type safety.

The #[Override] attribute provides compile-time verification that this method actually overrides a parent method, helping catch potential issues during refactoring.

.github/workflows/continuous-integration.yml (1)

12-13: LGTM! CI configuration updated for PHP 8.4 support.

The workflow parameters are correctly configured to support PHP 8.4 as the current stable version, with appropriate JSON formatting for the old_stable parameter and string formatting for current_stable.

tests/AuraSqlModuleTest.php (1)

23-23: LGTM! Consistent style improvement across test methods.

The removal of unnecessary parentheses around object instantiations improves code readability and follows modern PHP conventions. All changes maintain identical functionality while improving consistency with the codebase style updates.

Also applies to: 29-30, 36-36, 43-43, 50-50, 69-69

src/TransactionalModule.php (3)

7-7: LGTM! Proper import for Override attribute.

The use Override; statement is correctly positioned and necessary for the #[Override] attribute used in the configure method.

---

11-11: LGTM! Final class declaration improves design.

Making the class final prevents unintended subclassing and clearly communicates the design intent, which is a good practice for module classes.

---

16-16: LGTM! Override attribute enhances type safety.

The #[Override] attribute provides compile-time verification that this method correctly overrides the parent class method, helping prevent errors during refactoring.

src/AuraSqlBaseModule.php (3)

7-7: LGTM: Override import added for PHP 8.3+ attribute support.

The import is correctly added to support the #[Override] attribute usage below.

---

13-13: LGTM: Class marked as final for improved immutability.

Making the class final prevents subclassing, which improves performance and ensures the intended design pattern. This aligns with the modernization effort in the codebase.

---

23-24: LGTM: Override attribute improves method override clarity.

The #[Override] attribute explicitly marks this method as overriding a parent method, providing better IDE support and compile-time checks if the parent signature changes.

tests/AuraSqlProfileModuleTest.php (3)

8-8: LGTM: PHPUnit attribute import added for modern test syntax.

The import enables the use of PHP 8 attributes for test dependencies, replacing docblock annotations.

---

50-50: LGTM: Simplified Injector instantiation syntax.

Removing unnecessary parentheses improves code readability without changing functionality.

---

56-56: LGTM: Modernized test dependency syntax with PHP 8 attributes.

The #[Depends('testModule')] attribute replaces the @depends docblock annotation, providing better IDE support and type safety in PHPUnit 10+.

src/ProfilerProvider.php (4)

8-8: LGTM: Override import added for attribute support.

The import enables the use of the #[Override] attribute below.

---

12-12: LGTM: Class marked as final readonly for improved immutability.

The final readonly declaration prevents subclassing and ensures all properties are immutable, enhancing security and performance.

---

14-14: LGTM: Removed redundant readonly from constructor parameter.

Since the class is declared readonly, all properties are automatically readonly, making the explicit readonly keyword on constructor parameters redundant.

---

18-19: LGTM: Override attribute improves method documentation.

The #[Override] attribute explicitly marks this method as implementing the Provider interface, providing better IDE support and compile-time validation.

src/AuraSqlReplicationDbProvider.php (4)

9-9: LGTM: Override import added for attribute support.

The import enables the use of the #[Override] attribute on interface method implementations.

---

15-15: LGTM: Class marked as final for improved design clarity.

Making the class final prevents subclassing, ensuring the intended provider pattern and improving performance.

---

28-29: LGTM: Override attribute on SetContextInterface implementation.

The #[Override] attribute explicitly marks this method as implementing the SetContextInterface, providing better IDE support and validation.

---

37-38: LGTM: Override attribute on ProviderInterface implementation.

The #[Override] attribute explicitly marks this method as implementing the ProviderInterface, ensuring compile-time validation and improving code documentation.

src/Pagerfanta/AuraSqlPagerModule.php (1)

7-7: LGTM! Excellent modernization with PHP 8.4 features.

The changes properly implement PHP 8.4 best practices:

• Added use Override; import for the attribute
• Made the class final to prevent subclassing and improve immutability
• Added #[Override] attribute to explicitly mark method override

These changes enhance code clarity and align with the broader modernization effort across the codebase.

Also applies to: 15-15, 20-20

tests/AuraSqlReplicationModuleTest.php (3)

10-10: LGTM! Proper PHPUnit modernization.

Added the necessary import for PHPUnit attributes to support the modern attribute syntax.

---

32-32: LGTM! Excellent adoption of PHPUnit 11 attribute syntax.

Replaced the legacy docblock annotation syntax with modern PHP 8 attributes for data providers. This is the recommended approach in PHPUnit 11 and improves code consistency.

Also applies to: 43-43, 54-54

---

37-37: LGTM! Clean syntax improvements.

Removed unnecessary parentheses around new Injector(...) expressions, improving code readability while maintaining the same functionality.

Also applies to: 48-48, 63-64

src/NamedPdoEnvModule.php (2)

8-8: LGTM! Consistent modernization with PHP 8.4 features.

The changes follow the same modernization pattern:

• Added use Override; import
• Made the class final for better immutability
• Added #[Override] attribute to explicitly mark method override

These changes are consistent with the codebase-wide modernization effort.

Also applies to: 11-11, 39-39

---

13-13:

✅ Verification successful

Verify PHP version compatibility for typed class constants.

The explicit string type on the class constant is a good practice, but static analysis indicates this feature requires PHP 8.3+. Since this PR targets PHP 8.4, this should be compatible, but please verify that the project's minimum PHP version supports this feature.

---

🏁 Script executed:

#!/bin/bash
# Description: Check the project's minimum PHP version requirement
# Expected: Should show PHP 8.4 as minimum version to confirm compatibility

# Check composer.json for PHP version requirements
cat composer.json | jq '.require.php'

# Check if there are any version constraints files
fd -t f 'composer.json' --exec cat {} \; | grep -E '"php":\s*"'

Length of output: 134

---

No action needed – PHP ^8.4 fully supports typed class constants

Your composer.json declares "php": "^8.4" and typed class constants (public const string …) have been supported since PHP 8.1, so this change is compatible.

🧰 Tools

🪛 PHPStan (2.1.15)

13-13: Class constants with native types are supported only on PHP 8.3 and later.

(classConstant.nativeTypeNotSupported)

.github/workflows/static-analysis.yml (1)

1-5: LGTM! Pragmatic temporary solution for PHP 8.4 compatibility.

The changes appropriately handle PHPMD's lack of PHP 8.4 support:

• Clear documentation explaining why PHPMD is temporarily excluded
• Updated workflow name to reflect the change
• Switched to appropriate reusable workflow without PHPMD

This is a well-documented temporary workaround that maintains static analysis coverage while addressing compatibility constraints.

Also applies to: 14-14

phpunit.xml.dist (1)

2-5: PHPUnit configuration upgrade looks good.

The migration from PHPUnit 9.3 to 11.0 schema is correctly implemented with the new requireCoverageMetadata="false" attribute.

tests/Pagerfanta/ExtendedPdoAdapterTest.php (2)

8-8: Good modernization with PHPUnit attributes.

The import for PHPUnit\Framework\Attributes\DataProvider is correctly added to support the new attribute syntax.

---

80-81: Excellent migration to PHP 8 attributes.

The conversion from @dataProvider docblock annotation to #[DataProvider('splProvider')] attribute aligns with modern PHPUnit best practices and improves type safety.

src/Pagerfanta/AuraSqlQueryAdapter.php (3)

9-9: Good addition of Override import.

The import for the Override attribute supports the modernization to PHP 8.3+ features.

---

21-21: Excellent use of final keyword.

Making the class final is a good practice for concrete adapter implementations, preventing unintended inheritance and improving code safety.

---

38-38:

❓ Verification inconclusive

Verify #[Override] attribute usage for interface implementations.

The #[Override] attribute is correctly applied to methods implementing the AdapterInterface. This enhances code safety by ensuring these methods actually override/implement interface methods.

Also applies to: 58-58

---

🏁 Script executed:

#!/bin/bash
# Description: Verify that #[Override] is used correctly for interface implementations
# Expected: The methods should actually implement AdapterInterface methods

# Check the AdapterInterface definition
echo "Checking AdapterInterface methods:"
ast-grep --pattern 'interface AdapterInterface {
  $$$
  getNbResults($$$) $$$
  $$$
  getSlice($$$) $$$
  $$$
}'

# Check for other classes using #[Override] with this interface
echo "Other implementations of AdapterInterface with #[Override]:"
rg -A 2 -B 1 "#\[Override\]" --type php

Length of output: 11812

---

🏁 Script executed:

#!/bin/bash
# Locate and display the AdapterInterface definition along with its methods
rg -Hn "interface AdapterInterface" -C 5

Length of output: 42

---

Cannot Verify #[Override] Usage—AdapterInterface Not Found

I was unable to locate the AdapterInterface declaration in this repository (it’s likely coming from an external package). Please confirm that it defines:

• getNbResults(): int
• getSlice(int $offset, int $length): iterable

so that these two methods in src/Pagerfanta/AuraSqlQueryAdapter.php truly implement the interface and justify the #[Override] annotations.

rector.php (2)

16-22: PHPUnit upgrade sets are well configured.

The inclusion of PHPUnitSetList versions 9.0, 10.0, and 11.0 provides a comprehensive upgrade path that aligns with the project's PHPUnit modernization goals.

---

8-13:

✅ Verification successful

Verify configured paths exist.

The Rector configuration includes paths for src, src-files, and tests. Please ensure all these directories exist in the project structure.

---

🏁 Script executed:

#!/bin/bash
# Description: Verify that all configured Rector paths exist
# Expected: All directories should exist

echo "Checking configured Rector paths:"
for dir in "src" "src-files" "tests"; do
    if [ -d "$dir" ]; then
        echo "✓ $dir directory exists"
    else
        echo "✗ $dir directory missing"
    fi
done

Length of output: 433

---

Rector configuration – paths verified

All configured Rector paths exist in the project:

• ✓ src
• ✓ src-files
• ✓ tests

The configuration structure looks good. You may still consider enabling some of Rector’s quality rule levels for deeper automated improvements.

src/AuraSqlMasterModule.php (4)

9-9: Excellent addition of modern PHP attributes.

The import statements for Override and SensitiveParameter attributes are properly added to support the new PHP 8.4 features used in this class.

Also applies to: 12-12

---

14-14: Good use of final keyword.

Making the class final prevents unintended inheritance and follows best practices for module classes that should not be extended.

---

23-24: Excellent security enhancement with #[SensitiveParameter].

The #[SensitiveParameter] attribute on the password parameter is a great security improvement that prevents sensitive data from being exposed in stack traces and debugging output.

---

37-38: Good explicit method override declaration.

The #[Override] attribute makes it clear that this method overrides a parent method, improving code clarity and enabling compile-time verification.

src/AuraSqlQueryInsertProvider.php (5)

9-9: Proper import for Override attribute.

The import statement correctly adds support for the #[Override] attribute used in this provider class.

---

14-14: Excellent use of final readonly class declaration.

Making the class final readonly provides both inheritance protection and immutability guarantees, which is perfect for provider classes that should be immutable value objects.

---

22-22: Correct property declaration for readonly classes.

Removing the explicit readonly keyword from the constructor parameter is the correct approach when the class is declared as readonly, as all properties become implicitly readonly. This avoids redundancy while maintaining immutability.

---

29-30: Good explicit interface method implementation.

The #[Override] attribute clearly indicates this method implements the ProviderInterface::get() method, improving code documentation and enabling compile-time verification.

---

32-32: Clean simplification of object instantiation.

Removing unnecessary parentheses from the QueryFactory instantiation improves code readability without changing functionality.

src/Pagerfanta/DefaultRouteGenerator.php (4)

7-7: Proper import for Override attribute.

The import statement correctly adds support for the #[Override] attribute used in this route generator class.

---

9-9: Excellent use of final readonly for route generator.

The final readonly declaration is perfect for this route generator class, ensuring immutability and preventing inheritance, which aligns with its purpose as a simple value object.

---

11-11: Correct property declaration consistency.

Removing the explicit readonly keyword from the constructor parameter is correct since the class is declared as readonly, making all properties implicitly readonly. This maintains consistency and avoids redundancy.

---

18-19: Good interface method documentation.

The #[Override] attribute on the __invoke method clearly indicates this implements the RouteGeneratorInterface::__invoke() method, improving code clarity and enabling compile-time verification of the interface contract.

src/Pagerfanta/FetchEntity.php (4)

8-8: Proper import for Override attribute.

The import statement correctly adds support for the #[Override] attribute used in this fetcher class.

---

14-14: Excellent immutability with final readonly declaration.

The final readonly class declaration is perfect for this entity fetcher, ensuring immutability and preventing inheritance, which is appropriate for this type of utility class.

---

16-16: Correct property declarations for readonly class.

Removing the explicit readonly keyword from both the $entity property and the $pdo constructor parameter is the correct approach when the class is declared as readonly. All properties become implicitly readonly, avoiding redundancy while maintaining the immutability guarantee.

Also applies to: 19-19

---

28-29: Good interface method documentation.

The #[Override] attribute on the __invoke method clearly indicates this implements the FetcherInterface::__invoke() method, improving code documentation and enabling compile-time verification of the interface implementation.

src/AuraSqlQueryUpdateProvider.php (5)

9-9: Good addition of Override import.

The import is correctly added to support the #[Override] attribute usage.

---

14-14: Excellent use of final readonly class declaration.

Making the class final readonly prevents inheritance and makes all properties implicitly readonly, which is a great improvement for immutability and type safety in PHP 8.4.

---

22-22: Correct removal of readonly from constructor parameter.

Since the class is now declared as readonly, all properties are implicitly readonly, so the explicit readonly modifier on the constructor parameter is redundant and correctly removed.

---

29-29: Proper use of #[Override] attribute.

The #[Override] attribute correctly indicates that this method implements the ProviderInterface::get() method, improving code clarity and enabling static analysis verification.

---

32-32: Good code style improvement.

Removing unnecessary parentheses around the new QueryFactory($this->db) expression improves readability.

src/AuraSqlQueryDeleteProvider.php (1)

9-32: Consistent and correct modernization.

All changes follow the same correct pattern as other provider classes:

• final readonly class for immutability
• Removal of redundant readonly from constructor parameter
• Proper #[Override] attribute on interface method
• Code style improvements

This consistency across provider classes is excellent.

src/AuraSqlQuerySelectProvider.php (1)

9-32: Good modernization with consistent pattern.

The changes correctly follow the same pattern as other provider classes with proper use of final readonly, #[Override], and constructor parameter adjustments.

src/Pagerfanta/AuraSqlPagerFactory.php (1)

8-25: Excellent modernization of factory class.

The changes correctly apply the same modernization pattern:

• final readonly class for immutability and preventing inheritance
• Proper removal of redundant readonly from constructor parameter
• Correct #[Override] attribute on interface method implementation
• Consistent with the pattern applied across other classes in this PR

The factory class is now properly modernized for PHP 8.4.

tests/Pagerfanta/AuraSqlPagerModuleTest.php (3)

7-7: LGTM: Proper import for PHP 8 PHPUnit attributes

Correctly imports the Depends attribute class to support the modernized dependency syntax.

---

18-18: LGTM: Code style improvement

The removal of unnecessary parentheses around new Injector(...) expressions improves code readability without affecting functionality.

Also applies to: 30-30, 103-103

---

41-41: LGTM: Modernized PHPUnit dependency attributes

Successfully migrated from deprecated PHPDoc @depends comments to PHP 8 #[Depends()] attributes. The dependency relationships are correctly preserved:

• testArrayAccess and testArrayAccessWithMaxPage depend on testNewInstance
• testArrayAccessWithBinding depends on testNewInstanceWithBinding

Also applies to: 61-61, 81-81

src/AuraSqlMasterDbInterceptor.php (5)

8-8: LGTM: Proper import for Override attribute

Correctly imports the Override attribute to support method override annotations.

---

13-13: LGTM: Enhanced immutability with final readonly class

Making the class final readonly prevents inheritance and ensures immutability, which is appropriate for this interceptor implementation.

---

15-15: LGTM: Typed constant improves type safety

Adding explicit string type to the constant enhances type safety. The static analysis warning about PHP 8.3+ requirement is not a concern since this PR targets PHP 8.4.

🧰 Tools

🪛 PHPStan (2.1.15)

15-15: Class constants with native types are supported only on PHP 8.3 and later.

(classConstant.nativeTypeNotSupported)

---

17-17: LGTM: Removed redundant readonly modifier

With the class declared as readonly, the readonly modifier on constructor parameters becomes redundant and is correctly removed.

---

24-24: LGTM: Proper Override attribute usage

The #[Override] attribute correctly documents that this method implements the MethodInterceptor interface.

src/AuraSqlConnectionInterceptor.php (5)

9-9: LGTM: Consistent Override import

Properly imports the Override attribute, maintaining consistency with other interceptor classes.

---

17-17: LGTM: Consistent final readonly pattern

Follows the same modernization pattern as other interceptor classes, enhancing immutability and preventing inheritance.

---

19-19: LGTM: Consistent typed constant

Matches the pattern used in other interceptor classes for type safety enhancement.

🧰 Tools

🪛 PHPStan (2.1.15)

19-19: Class constants with native types are supported only on PHP 8.3 and later.

(classConstant.nativeTypeNotSupported)

---

23-23: LGTM: Correct removal of redundant readonly modifiers

Both constructor parameters correctly have their readonly modifiers removed since the class-level readonly declaration makes them redundant.

Also applies to: 26-26

---

33-33: LGTM: Consistent Override attribute usage

Properly documents the interface method implementation, maintaining consistency across interceptor classes.

src/AuraSqlSlaveDbInterceptor.php (5)

8-8: LGTM: Consistent Override import

Maintains consistency with other interceptor classes in the modernization effort.

---

13-13: LGTM: Consistent final readonly implementation

Follows the established pattern for interceptor class modernization, enhancing immutability and preventing inheritance.

---

18-18: LGTM: Consistent typed constant pattern

Matches the type safety enhancement applied consistently across all interceptor classes.

🧰 Tools

🪛 PHPStan (2.1.15)

18-18: Class constants with native types are supported only on PHP 8.3 and later.

(classConstant.nativeTypeNotSupported)

---

20-20: LGTM: Correct readonly modifier removal

Properly removes the redundant readonly modifier from the constructor parameter, consistent with class-level readonly declaration.

---

27-27: LGTM: Proper Override attribute usage

Correctly documents the interface method implementation, completing the consistent modernization pattern across all interceptor classes.

src/Pagerfanta/AuraSqlPager.php (3)

8-8: Good addition of Override import for PHP 8.3+ compatibility.

The import is correctly added to support the #[Override] attributes used throughout the class.

---

21-21: Excellent modernization with final class declaration.

Making the class final follows modern PHP best practices and prevents unintended inheritance, which aligns with the immutable design pattern being adopted in this codebase.

---

49-50: Perfect implementation of #[Override] attributes.

All #[Override] attributes are correctly applied to methods that implement interface methods:

• init() implements AuraSqlPagerInterface
• offsetExists(), offsetGet(), offsetSet(), offsetUnset() implement ArrayAccess

This provides excellent documentation and compile-time verification of method overrides.

Also applies to: 63-65, 75-76, 101-102, 110-111

README.md (4)

5-5: Correct CI badge update for 2.x branch.

The continuous integration badge properly points to the 2.x branch, aligning with the new major version release.

---

9-13: Clear requirements specification for v2.x.

The requirements section clearly communicates the PHP ^8.4 and Aura.Sql ^6.0 dependencies, helping users understand the upgrade requirements.

---

22-30: Excellent version compatibility documentation.

The version compatibility table provides clear guidance for users on which versions to use based on their PHP version, with helpful branch links and status information.

🧰 Tools

🪛 LanguageTool

[uncategorized] ~24-~24: A punctuation mark might be missing here.
Context: ...| PHP | Aura.Sql | Branch | Status | |---------|---------|----------|--------...

(AI_EN_LECTOR_MISSING_PUNCTUATION)

---

136-136: Good fix for missing code block delimiter.

The addition of the closing ``` properly terminates the code block formatting.

src/Pagerfanta/AuraSqlQueryPagerFactory.php (3)

9-9: Proper Override import addition.

The import is correctly added to support the #[Override] attribute used on the newInstance method.

---

11-13: Excellent readonly class implementation.

The changes correctly implement a final readonly class:

• final readonly prevents inheritance and makes all properties immutable
• Removing readonly from the constructor parameter is correct since readonly classes automatically make all properties readonly
• This modernizes the code to use PHP 8.2+ features effectively

---

20-21: Correct #[Override] usage for interface method.

The #[Override] attribute is properly applied to the newInstance method that implements the AuraSqlQueryPagerFactoryInterface.

src/TransactionalInterceptor.php (3)

8-8: Appropriate Override import for method annotation.

The import supports the #[Override] attribute used on the invoke method.

---

17-19: Consistent readonly class modernization.

The implementation follows the same excellent pattern as other classes in this PR:

• final readonly class prevents inheritance and ensures immutability
• Removing readonly from the constructor parameter is correct since readonly classes make all properties readonly automatically
• This maintains functionality while leveraging PHP 8.2+ features

---

26-27: Proper #[Override] usage for interceptor method.

The #[Override] attribute correctly documents that the invoke method implements the MethodInterceptor interface, providing compile-time verification.

src/NamedPdoModule.php (5)

10-12: LGTM! Modern PHP imports added correctly.

The addition of Override and SensitiveParameter imports aligns with the PHP 8.4 modernization goals.

---

14-14: Excellent use of final keyword.

Making the module class final is a good practice that prevents unintended inheritance and improves code clarity in dependency injection contexts.

---

16-16: Good modernization with typed constant.

Adding explicit string type to the constant improves type safety and code clarity. The static analysis warning about PHP 8.3+ requirement is not a concern since this PR targets PHP 8.4.

🧰 Tools

🪛 PHPStan (2.1.15)

16-16: Class constants with native types are supported only on PHP 8.3 and later.

(classConstant.nativeTypeNotSupported)

---

31-32: Excellent security practice with SensitiveParameter.

The #[SensitiveParameter] attribute on the password parameter helps prevent accidental exposure in stack traces, logs, and debugging output - a crucial security enhancement.

---

43-44: Proper use of Override attribute.

The #[Override] attribute makes the inheritance intention explicit and will help catch errors if the parent method signature changes in the future.

UPGRADE.md (1)

1-91: Excellent comprehensive upgrade documentation.

This documentation effectively addresses all key concerns users might have about the v1.x to v2.x upgrade:

✅ Strengths:

• Clear explanation that no API changes were made despite major version bump
• Comprehensive version compatibility matrix
• Step-by-step migration guide
• Helpful FAQ section addressing common concerns
• Good technical context about PHP 8.4 PDO changes

The language tool suggestions are minor and don't impact the clarity or usefulness of the documentation.

🧰 Tools

🪛 LanguageTool

[uncategorized] ~57-~57: A punctuation mark might be missing here.
Context: ...-----|-------------|----------|--------| | v1.x | ^8.1 | ^5.0...

(AI_EN_LECTOR_MISSING_PUNCTUATION)

---

[style] ~69-~69: ‘exactly the same’ might be wordy. Consider a shorter alternative.
Context: ...* All public APIs and interfaces remain exactly the same. #### Q: Why the major version bump? *...

(EN_WORDINESS_PREMIUM_EXACTLY_THE_SAME)

---

[style] ~86-~86: Consider using a different verb to strengthen your wording.
Context: ...ray-di/Ray.AuraSqlModule/issues) if you find any problems ### Technical Details Th...

(FIND_ENCOUNTER)

---

[uncategorized] ~90-~90: You might be missing the article “the” here.
Context: ...roduced in PHP 8.4. The underlying Aura.Sql library handles these changes transpare...

(AI_EN_LECTOR_MISSING_DETERMINER_THE)

src/Pagerfanta/AuraSqlQueryPager.php (3)

11-11: Proper import for Override attribute.

Good addition of the Override import to support the modernization efforts.

---

22-22: Appropriate use of final keyword.

Making this concrete pager implementation final prevents unintended inheritance and improves code clarity.

---

48-49: Excellent use of Override attributes on interface methods.

All interface methods (init, offsetGet, offsetExists, offsetSet, offsetUnset) are properly annotated with #[Override] attributes. This makes the interface implementation explicit and will help catch errors if interface signatures change.

Also applies to: 63-64, 96-97, 105-106, 114-115

src/Pagerfanta/ExtendedPdoAdapter.php (4)

8-8: Proper import for Override attribute.

Good addition of the Override import to support the interface method annotations.

---

28-28: Excellent use of readonly class feature.

The final readonly class declaration is a great use of PHP 8.4 features that makes all properties readonly automatically, improving immutability and type safety.

---

30-30: Correct property and constructor parameter handling for readonly class.

Since the class is declared readonly, individual properties don't need the readonly keyword and constructor parameters are automatically promoted to readonly properties. This is the correct approach for readonly classes.

Also applies to: 33-33

---

43-44: Proper Override annotations on interface methods.

The #[Override] attributes on getNbResults() and getSlice() methods correctly indicate these implement the AdapterInterface. This improves code clarity and helps catch interface changes.

Also applies to: 77-78

Reviewing files that changed from the base of the PR and between 9096c27 and 6d10b73.

• README.md (9 hunks)

README.md (2)

105-105:

✅ Verification successful

Check NamedPdoModule constructor signature

Please verify that the constructor signature matches these parameters and order:

$this->install(new NamedPdoModule(
    'log_db',                            // qualifier
    'mysql:host=localhost;dbname=log',   // DSN
    'username',                          // user
    'password'                           // password
));

Run:

to confirm the constructor’s parameters.

---

🏁 Script executed:

rg -n "class NamedPdoModule" -n src

Length of output: 113

---

Let’s extract the constructor signature directly from the module:

---

🏁 Script executed:

#!/bin/bash
grep -R "function __construct" -n src/NamedPdoModule.php

Length of output: 94

---

Let’s pull the constructor parameters to verify their order:

---

🏁 Script executed:

#!/bin/bash
sed -n '27,40p' src/NamedPdoModule.php

Length of output: 468

---

Constructor signature matches invocation

The NamedPdoModule constructor is defined as:

1. string $qualifer
2. string $dsn
3. string $username = ''
4. string $password = ''
5. $slave, $options, $queries (all with defaults)

Your README usage passes exactly the first four arguments in the correct order, so no changes are needed.

---

117-117:

✅ Verification successful

Verify NamedPdoEnvModule parameters

Likewise, ensure NamedPdoEnvModule accepts these env keys in order:

$this->install(new NamedPdoEnvModule(
    'log_db', 
    'LOG_DSN', 
    'LOG_USERNAME', 
    'LOG_PASSWORD'
));

Use:

to validate it.

---

🏁 Script executed:

rg -n "class NamedPdoEnvModule" -n src

Length of output: 122

---

🏁 Script executed:

#!/bin/bash
# Show the constructor signature of NamedPdoEnvModule to verify parameter order
rg -n "function __construct" -n src/NamedPdoEnvModule.php -A3 -B3

Length of output: 432

---

🏁 Script executed:

#!/bin/bash
# Display full constructor signature including all parameters
rg -n "public function __construct" -n src/NamedPdoEnvModule.php -A7 -B0

Length of output: 444

---

No changes needed for NamedPdoEnvModule parameters

The constructor signature in src/NamedPdoEnvModule.php is:

public function __construct(
    private readonly string $qualifer,
    private readonly string $dsn,
    private readonly string $username = '',
    private readonly string $password = '',
    private readonly string $slave    = '',
    private readonly array  $options  = [],
    private readonly array  $queries  = []
) { … }

Your call in README.md:

$this->install(new NamedPdoEnvModule(
    'log_db',
    'LOG_DSN',
    'LOG_USERNAME',
    'LOG_PASSWORD'
));

correctly maps to (qualifer, dsn, username, password) with all remaining parameters using their defaults. No update is required.

Reviewing files that changed from the base of the PR and between 817e8a1 and 30ac750.

• README.md (10 hunks)

README.md (5)

11-13: Code block formatting for installation command
Great use of a fenced code block with the bash language specifier to highlight the installation steps.

---

15-15: Clear “Getting started” heading added
The new heading improves the structure and navigability of the README.

---

84-84: Attribute syntax for Named is correctly updated
Switching to #[Named($qualifier)] aligns the documentation with PHP 8 attribute usage.

---

138-138: Transactional attribute description
Switching to #[Transactional] for code examples aligns well with PHP 8 attribute usage.

---

148-149: Combined attributes are clear and concise
Using #[WriteConnection, Transactional] reduces clutter and modernizes the example.

Reviewing files that changed from the base of the PR and between 30ac750 and 5b79ff1.

• README.md (10 hunks)
• phpunit.xml.dist (1 hunks)

phpunit.xml.dist (3)

4-5: Modern PHPUnit 12 configuration attributes properly applied.

The addition of requireCoverageMetadata="false" is appropriate for PHPUnit 12, which requires explicit declaration of coverage metadata handling. This helps maintain compatibility with the upgraded PHPUnit version.

---

6-10: Source configuration modernized for PHPUnit 12.

The explicit <source> element definition follows PHPUnit 12's recommended structure for defining code coverage scope. This replaces the older implicit configuration approach and provides clearer separation of concerns.

---

12-17: Coverage reporting configuration updated to PHPUnit 12 format.

The restructured <coverage> element with nested <report> elements follows the modern PHPUnit 12 XML schema. The configuration correctly defines both HTML and text output formats with appropriate destinations.

README.md (22)

11-13: Good: Added installation code fence
Using a fenced bash code block for the composer command improves readability.

---

33-36: Clarified optional constructor parameters
The inclusion of the slave list, driver options, and post-connection queries is clear and well-documented.

---

45-54: Documented environment-based module usage
The AuraSqlEnvModule example with environment variables and optional parameters is accurate and helpful.

---

62-75: Replication example updated for PHP 8.4
The new replication snippet correctly uses ConnectionLocator and demonstrates installing AuraSqlReplicationModule.

---

84-84: Modernized to PHP 8 attribute syntax
Switching from annotation to #[Named($qualifier)] aligns with the codebase modernization.

---

89-89: Example updated for named injection
The parameter-level #[Named('log_db')] attribute is correctly demonstrated.

---

105-105: NamedPdoModule usage documented
The NamedPdoModule example is clear and matches the updated API.

---

117-117: NamedPdoEnvModule usage documented
The environment-based named PDO example is correctly illustrated.

---

124-131: Qualifier parameter for replication documented
Demonstrating how to pass the $qualifier to AuraSqlReplicationModule is straightforward.

---

138-138: Transactional attribute description
The explanation for #[Transactional] is concise and accurate.

---

160-163: Query builder interface list
Listing each interface in bullet form is clear and matches the updated providers.

---

166-174: Constructor injection example
Using readonly properties and typed constructor parameters is correctly shown.

---

178-185: Select query builder example
The chainable builder methods are properly demonstrated with PHP 8 syntax.

---

205-209: Multiple query builders injection
The UserService constructor example correctly injects all four query interfaces.

---

214-220: createUser example
The insert workflow example aligns with the updated API.

---

224-233: updateUser example
The update workflow example is clear and accurate.

---

245-252: Pagination factory injection
Showing AuraSqlPagerFactoryInterface with typed readonly properties is accurate.

---

255-261: ExtendedPdo pagination example
The $pager = $pagerFactory->newInstance(...) usage is well-documented.

---

269-277: Select query pager factory injection
The AuraSqlQueryPagerFactoryInterface and SelectInterface injection example is correct.

---

283-290: getProductList example
The query pager usage with $select and dynamic URL is properly shown.

---

312-314: Iterable Page example
Demonstrating iteration over $page improves clarity on usage.

---

342-353: Profile module logger example
The anonymous class logger and AuraSqlProfileModule installation are correctly demonstrated.